home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / fp.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  24.5 KB  |  610 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        fp.mod
  3.  
  4.      Copyright:    © 1994-1995 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Pascal, March 29, 1995 
  8.     
  9.     Note:        The following file was hand converted from fp.h
  10.                 See fp.h for more information and comments.
  11. *)
  12.  
  13.  
  14. (*$TAGS-*)
  15. (*$CALLING PASCAL*)
  16. MODULE fp;
  17.  
  18. IMPORT SYSTEM, Types;
  19.  
  20. TYPE
  21.     Double* = REAL; (*ΔΔ NEW*)
  22.     Single* = LONGINT; (*ΔΔ NEW*)
  23. CONST
  24.     DOUBLE_SIZE*                    = 8;
  25.  
  26. (*$IF GENERATINGPOWERPC *)
  27.     LONG_DOUBLE_SIZE*            = 16;
  28.     DECIMAL_DIG*                    = 17;  (* does not exist for double-double *)
  29. (*$ELSE*)
  30.     DECIMAL_DIG*                    = 21;
  31. (*$IF GENERATING68881*)
  32.     LONG_DOUBLE_SIZE*            = 12;
  33. (*$ELSE*)
  34.     LONG_DOUBLE_SIZE*            = 10;
  35. (*$END*)
  36. (*$END*)
  37.  
  38. (*******************************************************************************
  39. *                            Trigonometric functions                           *
  40. *******************************************************************************)
  41.  
  42.  
  43. (*•• PROCEDURE cos*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  44.     EXTERNAL (*•• C*);*)
  45. (*•• PROCEDURE sin*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  46.     EXTERNAL (*•• C*);*)
  47. (*•• PROCEDURE tan*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  48.     EXTERNAL (*•• C*);*)
  49.  
  50. (*•• PROCEDURE acos*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  51.     EXTERNAL (*•• C*);*)    (*  result is in [0,pi]          *)
  52. (*•• PROCEDURE asin*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  53.     EXTERNAL (*•• C*);*)    (*  result is in [-pi/2,pi/2]    *)
  54. (*•• PROCEDURE atan*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  55.     EXTERNAL (*•• C*);*)    (*  result is in [-pi/2,pi/2]    *)
  56.  
  57. (*    atan2 computes the arc tangent of y/x in [-pi,pi] using the sign of
  58.       both arguments to determine the quadrant of the computed value.         *)
  59. (*•• PROCEDURE atan2*(y: Types.double_t; x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  60.     EXTERNAL (*•• C*);*)
  61.  
  62.  
  63. (*******************************************************************************
  64. *                              Hyperbolic functions                            *
  65. *******************************************************************************)
  66.  
  67. (*•• PROCEDURE cosh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  68.     EXTERNAL (*•• C*);*)
  69. (*•• PROCEDURE sinh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  70.     EXTERNAL (*•• C*);*)
  71. (*•• PROCEDURE tanh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  72.     EXTERNAL (*•• C*);*)
  73. (*•• PROCEDURE acosh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  74.     EXTERNAL (*•• C*);*)
  75. (*•• PROCEDURE asinh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  76.     EXTERNAL (*•• C*);*)
  77. (*•• PROCEDURE atanh*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  78.     EXTERNAL (*•• C*);*)
  79.  
  80. (*******************************************************************************
  81. *                              Exponential functions                           *
  82. *******************************************************************************)
  83.  
  84. (*•• PROCEDURE exp*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  85.     EXTERNAL (*•• C*);*)
  86.  
  87. (*    expm1 computes the base e exponential of the argument minus 1,
  88.       i. e., exp(x) - 1.  For small enough arguments, expm1 is expected
  89.       to be more accurate than the straight forward computation of exp(x) - 1.*)
  90. (*•• PROCEDURE expm1*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  91.     EXTERNAL (*•• C*);*)
  92.  
  93. (*      exp2 computes the base 2 exponential.                                 *)
  94. (*•• PROCEDURE exp2*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  95.     EXTERNAL (*•• C*);*)
  96. (*•• PROCEDURE frexp*(x: Types.double_t; VAR exponent: LONGINT): Types.double_t; (*ΔΔC;ΔΔ*)
  97.     EXTERNAL (*•• C*);*)
  98. (*•• PROCEDURE ldexp*(x: Types.double_t; n: LONGINT): Types.double_t; (*ΔΔC;ΔΔ*)
  99.     EXTERNAL (*•• C*);*)
  100. (*•• PROCEDURE log*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  101.     EXTERNAL (*•• C*);*)
  102.  
  103. (*      log2 computes the base 2 logarithm.                                   *)
  104. (*•• PROCEDURE log2*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  105.     EXTERNAL (*•• C*);*)
  106.  
  107. (*    log1p computes the base e logorithm of 1 plus the argument,
  108.       i. e., log (1 x).  For small enough arguments, log1p is expected
  109.       to be more accurate than the straightforward computation of log (1+x).  *)
  110. (*•• PROCEDURE log1p*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  111.     EXTERNAL (*•• C*);*)
  112. (*•• PROCEDURE log10*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  113.     EXTERNAL (*•• C*);*)
  114.  
  115. (*    logb extracts the exponent of its argument, as a signed integral
  116.       value. A subnormal argument is treated as though it were first
  117.       normalized. Thus
  118.  
  119.       1 <= x  2POINTER TO ( - Logb ( x ) ) < 2                                         *)
  120. (*•• PROCEDURE logb*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  121.     EXTERNAL (*•• C*);*)
  122. (*•• PROCEDURE modf*(x: Double; VAR iptr: Double): Double; (*ΔΔC;ΔΔ*)
  123.     EXTERNAL (*•• C*);*)
  124. PROCEDURE modff*(x: Single; VAR iptrf: Single): Single; (*ΔΔC;ΔΔ*)
  125.     EXTERNAL (*•• C*);
  126.  
  127. (*    scalb computes x  2POINTER TO n efficently.  This is not normally done by
  128.       computing 2POINTER TO n explicitly.                                               *)
  129. (*•• PROCEDURE scalb*(x: Types.double_t; n: LONGINT): Types.double_t; (*ΔΔC;ΔΔ*)
  130.     EXTERNAL (*•• C*);*)
  131.  
  132. (*******************************************************************************
  133. *                     Power and absolute value functions                       *
  134. *******************************************************************************)
  135.  
  136. (*•• PROCEDURE fabs*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  137.     EXTERNAL (*•• C*);*)
  138.  
  139. (*    hypot computes the square root of the sum of the squares of its
  140.       arguments, without undue overflow or underflow.                         *)
  141. (*•• PROCEDURE hypot*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  142.     EXTERNAL (*•• C*);*)
  143. (*•• PROCEDURE pow*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  144.     EXTERNAL (*•• C*);*)
  145. (*•• PROCEDURE sqrt*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  146.     EXTERNAL (*•• C*);*)
  147.  
  148. (*******************************************************************************
  149. *                        Gamma and Error functions                             *
  150. *******************************************************************************)
  151.  
  152. (*•• PROCEDURE erf*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  153.     EXTERNAL (*•• C*);*)
  154. (*•• PROCEDURE erfc*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  155.     EXTERNAL (*•• C*);*)    (*   complementary error function   *)
  156.  
  157. (*•• PROCEDURE gamma*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  158.     EXTERNAL (*•• C*);*)
  159.  
  160. (*    lgamma computes the base-e logarithm of the absolute value of
  161.       gamma of its argument x, for x > 0.                                     *)
  162. (*•• PROCEDURE lgamma*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  163.     EXTERNAL (*•• C*);*)
  164.  
  165. (*******************************************************************************
  166. *                        Nearest integer functions                             *
  167. *******************************************************************************)
  168.  
  169. (*•• PROCEDURE ceil*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  170.     EXTERNAL (*•• C*);*)
  171. (*•• PROCEDURE floor*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  172.     EXTERNAL (*•• C*);*)
  173.  
  174. (*    the rint function rounds its argument to an integral value in floating
  175.       point format, honoring the current rounding direction.                  *)
  176. (*•• PROCEDURE rint*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  177.     EXTERNAL (*•• C*);*)
  178.  
  179. (*    nearbyint differs from rint only in that it does not raise the
  180.       inexact exception. It is the nearbyint function recommended by the
  181.       IEEE floating-point standard 854.                                       *)
  182. (*•• PROCEDURE nearbyint*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  183.     EXTERNAL (*•• C*);*)
  184.  
  185. (*    the function rinttol rounds its argument to the nearest long using
  186.       the current rounding direction.
  187.       >>Note that if the rounded value is outside the range of long, then
  188.       the result is undefined.                                                *)
  189. (*•• PROCEDURE rinttol*(x: Types.double_t): LONGINT; (*ΔΔC;ΔΔ*)
  190.     EXTERNAL (*•• C*);*)
  191.  
  192. (*    the round function rounds the argument to the nearest integral value
  193.       in double format similar to the Fortran "anint" function.  That is:
  194.       add half to the magnitude and chop.                                     *)
  195. (*•• PROCEDURE round*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  196.     EXTERNAL (*•• C*);*)
  197.  
  198. (*    roundtol is similar to the Fortran function nint or to the Pascal round
  199.       >>Note that if the rounded value is outside the range of long, then
  200.       the result is undefined.                                                *)
  201. (*•• PROCEDURE roundtol*(round: Types.double_t): LONGINT; (*ΔΔC;ΔΔ*)
  202.     EXTERNAL (*•• C*);*)
  203.  
  204. (*    trunc computes the integral value, in floating format, nearest to
  205.       but no larger in magnitude than its argument.                           *)
  206. (*•• PROCEDURE trunc*(x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  207.     EXTERNAL (*•• C*);*)
  208.  
  209. (*******************************************************************************
  210. *                            Remainder functions                               *
  211. *******************************************************************************)
  212.  
  213. (*•• PROCEDURE fmod*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  214.     EXTERNAL (*•• C*);*)
  215.  
  216. (*    the following two functions compute the remainder.  remainder is required
  217.       by the IEEE 754 floating point standard. The second form correponds to the
  218.       SANE remainder; it stores into 'quotient' the 7 low-order bits of the
  219.       integer quotient x/y, such that -127 <= quotient <= 127.                *)
  220. (*•• PROCEDURE remainder*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  221.     EXTERNAL (*•• C*);*)
  222. (*•• PROCEDURE remquo*(x: Types.double_t; y: Types.double_t; VAR quo: LONGINT): Types.double_t; (*ΔΔC;ΔΔ*)
  223.     EXTERNAL (*•• C*);*)
  224.  
  225.  
  226. (*******************************************************************************
  227. *                             Auxiliary functions                              *
  228. *******************************************************************************)
  229.  
  230. (*•• PROCEDURE copysign*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  231.     EXTERNAL (*•• C*);*)
  232. PROCEDURE nan*(tagp: Types.ConstCStringPtr): Double; (*ΔΔC;ΔΔ*)
  233.     EXTERNAL (*•• C*);
  234. PROCEDURE nanf*(tagp: Types.ConstCStringPtr): Single; (*ΔΔC;ΔΔ*)
  235.     EXTERNAL (*•• C*);
  236.  
  237. (*•• PROCEDURE nextafterd*(x: Double; y: Double): Double; (*ΔΔC;ΔΔ*)
  238.     EXTERNAL (*•• C*);*)
  239. PROCEDURE nextafterf*(x: Single; y: Single): Single; (*ΔΔC;ΔΔ*)
  240.     EXTERNAL (*•• C*);
  241.  
  242. (*******************************************************************************
  243. *                      Max, Min and Positive Difference                        *
  244. *******************************************************************************)
  245.  
  246. (*     These extension functions correspond to the standard functions, dim
  247.       max and min.
  248.  
  249.       The fdim function determines the 'positive difference' between its
  250.       arguments: ( x - y, if x > y ), ( +0, if x <= y ).  If one argument is
  251.       NaN, then fdim returns that NaN.  if both arguments are NaNs, then fdim
  252.       returns the first argument.                                             *)
  253. (*•• PROCEDURE fdim*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  254.     EXTERNAL (*•• C*);*)
  255.  
  256. (*    max and min return the maximum and minimum of their two arguments,
  257.       respectively.  They correspond to the max and min functions in FORTRAN.
  258.       NaN arguments are treated as missing data.  If one argument is NaN and
  259.       the other is a number, then the number is returned.  If both are NaNs
  260.       then the first argument is returned.                                    *)
  261. (*•• PROCEDURE fmax*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  262.     EXTERNAL (*•• C*);*)
  263. (*•• PROCEDURE fmin*(x: Types.double_t; y: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  264.     EXTERNAL (*•• C*);*)
  265.  
  266. (*******************************************************************************
  267. *                              Inquiry functions                               *
  268. *******************************************************************************)
  269.  
  270. CONST
  271.     FP_SNAN*     = 0;        (*      signaling NaN                         *)
  272.     FP_QNAN*     = 1;        (*      quiet NaN                             *)
  273.     FP_INFINITE* = 2;        (*      + or - infinity                       *)
  274.     FP_ZERO*        = 3;        (*      + or - zero                           *)
  275.     FP_NORMAL*    = 4;        (*      all normal numbers                    *)
  276.     FP_SUBNORMA* = 5;        (*      denormal numbers                      *)
  277.  
  278.  
  279. (*•• PROCEDURE __fpclassifyd*(x: Double): LONGINT; (*ΔΔC;ΔΔ*)
  280.     EXTERNAL (*•• C*);*)
  281. PROCEDURE __fpclassifyf*(x: Single): LONGINT; (*ΔΔC;ΔΔ*)
  282.     EXTERNAL (*•• C*);
  283.  
  284. (*•• PROCEDURE __isnormald*(x: Double) : LONGINT; (*ΔΔC;ΔΔ*)
  285.     EXTERNAL (*•• C*);*)
  286. PROCEDURE __isnormalf*(x: Single): LONGINT; (*ΔΔC;ΔΔ*)
  287.     EXTERNAL (*•• C*);
  288.  
  289. (*•• PROCEDURE __isfinited*(x: Double): LONGINT; (*ΔΔC;ΔΔ*)
  290.     EXTERNAL (*•• C*);*)
  291. PROCEDURE __isfinitef*(x: Single): LONGINT; (*ΔΔC;ΔΔ*)
  292.     EXTERNAL (*•• C*);
  293.  
  294. (*•• PROCEDURE __isnand*(x: Double): LONGINT; (*ΔΔC;ΔΔ*)
  295.     EXTERNAL (*•• C*);*)
  296. PROCEDURE __isnanf*(x: Single): LONGINT; (*ΔΔC;ΔΔ*)
  297.     EXTERNAL (*•• C*);
  298.  
  299. (*•• PROCEDURE __signbitd*(x: Double): LONGINT; (*ΔΔC;ΔΔ*)
  300.     EXTERNAL (*•• C*);*)
  301. PROCEDURE __signbitf*(x: Single): LONGINT; (*ΔΔC;ΔΔ*)
  302.     EXTERNAL (*•• C*);
  303.  
  304. (*•• PROCEDURE __inf*(): Double;
  305.     EXTERNAL PASCAL;*)
  306.  
  307.  
  308. (*******************************************************************************
  309. *                              Non NCEG extensions                             *
  310. *******************************************************************************)
  311.  
  312.  
  313. (*$IF UNDEFINED __NOEXTENSIONS__ *)
  314.  
  315. (*******************************************************************************
  316. *                              Financial functions                             *
  317. *******************************************************************************)
  318.  
  319. (*     compound computes the compound interest factor "(1 + rate) POINTER TO  periods"
  320.       more accurately than the straightforward computation with the Power
  321.       function.  This is SANE's compound function.                            *)
  322. (*•• PROCEDURE compound*(rate: Types.double_t; periods: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  323.     EXTERNAL (*•• C*);*)
  324.  
  325. (*    The function annuity computes the present value factor for an annuity 
  326.       "( 1 - ( 1 + rate ) POINTER TO  ( - periods ) ) / rate" more accurately than the
  327.       straightforward computation with the Power function. This is SANE's 
  328.       annuity function.                                                       *)
  329. (*•• PROCEDURE annuity*(rate: Types.double_t; periods: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  330.     EXTERNAL (*•• C*);*)
  331.  
  332. (*******************************************************************************
  333. *                              Random function                                 *
  334. *******************************************************************************)
  335.  
  336. (*•• PROCEDURE randomx*(VAR x: Types.double_t): Types.double_t; (*ΔΔC;ΔΔ*)
  337.     EXTERNAL (*•• C*);*)
  338.  
  339.  
  340. (*******************************************************************************
  341. *                              Relational operator                             *
  342. *******************************************************************************)
  343.  
  344. TYPE
  345.     relop* = INTEGER;        (*      relational operator      *)
  346.  
  347. CONST
  348.     GREATERTHAN*                    = 0;
  349.     LESSTHAN*                    = 1;
  350.     EQUALTO*                        = 2;
  351.     UNORDERED*                    = 3;
  352.  
  353.  
  354. (*•• PROCEDURE relation*(x: Types.double_t; y: Types.double_t): relop; (*ΔΔC;ΔΔ*)
  355.     EXTERNAL (*•• C*);*)
  356.  
  357.  
  358.  
  359. (*******************************************************************************
  360. *                         Binary to decimal conversions                        *
  361. *******************************************************************************)
  362.  
  363. CONST
  364. (*$IF GENERATINGPOWERPC *)
  365.     SIGDIGLEN*                    = 36;                    (* significant decimal digits *)
  366. (*$ELSE*)
  367.     SIGDIGLEN*                    = 20;                    (* significant decimal digits *)
  368. (*$END*)
  369.     DECSTROUTLEN*                = 80;                    (* max length for dec2str output *)
  370.  
  371. TYPE
  372.     (*ΔΔ DecimalKind* = (FloatDecimal,FixedDecimal);*)
  373.     DecimalKind* = SHORTINT;
  374. CONST
  375.     FloatDecimal* = 0; FixedDecimal* = 1;
  376. TYPE
  377.  
  378. (*     The decimal record type provides an intermediate unpacked form for
  379.       programmers who wish to do their own parsing of numeric input or
  380.       formatting of numeric output.                                         *)
  381.     
  382.     (* $ALIGN MAC68K*)
  383.     Decimal* = RECORD
  384.         sgn*:     SHORTINT (*ΔΔ 0..1*);            (* sign 0 for +, 1 for -  *)
  385.         exp*:     INTEGER;
  386.         sig*:     ARRAY SIGDIGLEN OF CHAR (*ΔΔ STRING[SIGDIGLEN]*);
  387.     END;
  388.     (* $ALIGN RESET*)
  389.  
  390. (*    Each conversion to a decimal string is controlled by a decform
  391.       structure.  The style is either FLOATDECIMAL or FIXEDDECIMAL defined
  392.       above.  The value of digits is the number of significant digits for
  393.       FLOATDECIMAL.  The value of digits for FIXEDDECIMAL is the number of
  394.       digits to the right of the decimal point.                               *)
  395.       
  396.     (* $ALIGN MAC68K*)
  397.     Decform* = RECORD
  398.         style*:     DecimalKind;
  399.         digits*: INTEGER;
  400.     END;
  401.     (* $ALIGN RESET*)
  402.     
  403. (*    Each conversion to a decimal record d via the function call num2dec is 
  404.       controlled by a decform record f (defined earlier), to a Types.double_t x.    *)
  405. (*•• PROCEDURE num2dec*((*CONST*)VAR f: Decform; x: Types.double_t; VAR d: Decimal); (*ΔΔC;ΔΔ*)
  406.     EXTERNAL (*•• C*);*)
  407.  
  408.  
  409. (* dec2num converts a decimal record d to a Types.double_t value.          *)
  410. PROCEDURE dec2num*((*CONST*)VAR d: Decimal): Types.double_t; (*ΔΔC;ΔΔ*)
  411.     EXTERNAL (*•• C*);
  412.  
  413. (*    The MathLib formatter dec2str is controlled by a decform f.  Input d is
  414.       a decimal record.                                                       *)
  415. PROCEDURE dec2str*((*CONST*)VAR f: Decform; (*CONST*)VAR d: Decimal; s: Types.CStringPtr); (*ΔΔC;ΔΔ*)
  416.     EXTERNAL (*•• C*);
  417.  
  418. (*    The function str2dec is the MathLib scanner.                            *)
  419. PROCEDURE str2dec*(s: Types.ConstCStringPtr; VAR ix: INTEGER; VAR d: Decimal; VAR vp: INTEGER); (*ΔΔC;ΔΔ*)
  420.     EXTERNAL (*•• C*);
  421.  
  422. (*$IF GENERATING68K *)
  423. (*    dec2d is similar to dec2num except a double is returned on 68k platforms *)
  424. PROCEDURE dec2d*((*CONST*)VAR d: Decimal): Double; (*ΔΔC;ΔΔ*)
  425.     EXTERNAL (*•• C*);
  426. (*$END*)
  427.  
  428. (*    dec2f is similar to dec2num except a float is returned.                 *)
  429. PROCEDURE dec2f*((*CONST*)VAR d: Decimal): Single; (*ΔΔC;ΔΔ*)
  430.     EXTERNAL (*•• C*);
  431.  
  432. (*    dec2s is similar to dec2num except a short is returned.                 *)
  433. PROCEDURE dec2s*((*CONST*)VAR d: Decimal): INTEGER; (*ΔΔC;ΔΔ*)
  434.     EXTERNAL (*•• C*);
  435.  
  436. (*    dec2l is similar to dec2num except a long is returned.                  *)
  437. PROCEDURE dec2l*((*CONST*)VAR d: Decimal): LONGINT; (*ΔΔC;ΔΔ*)
  438.     EXTERNAL (*•• C*);
  439.  
  440. (*******************************************************************************
  441. *                    68k-only Transfer Function Prototypes                     *
  442. *******************************************************************************)
  443.  
  444. (*$IF GENERATING68K *)
  445.  
  446. (*•• PROCEDURE x96tox80*((*CONST*)VAR x96: Types.Extended96; VAR x80: Types.Extended80); (*ΔΔC;ΔΔ*)
  447.     EXTERNAL (*•• C*);*)
  448. (*•• PROCEDURE x80tox96*((*CONST*)VAR x80: Types.Extended80; VAR x96: Types.Extended96); (*ΔΔC;ΔΔ*)
  449.     EXTERNAL (*•• C*);*)
  450.  
  451. (*$END*)     (* GENERATING68K *)
  452.  
  453.  
  454. (*$END*) (*__NOEXTENSIONS__*)
  455.  
  456. (*******************************************************************************
  457. *                         PowerPC-only Function Prototypes                     *
  458. *******************************************************************************)
  459.  
  460. (*$IF GENERATINGPOWERPC *)
  461. PROCEDURE cosl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  462.     EXTERNAL (*•• C*);
  463. PROCEDURE sinl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  464.     EXTERNAL (*•• C*);
  465. PROCEDURE tanl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  466.     EXTERNAL (*•• C*);
  467.  
  468. PROCEDURE acosl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  469.     EXTERNAL (*•• C*);
  470. PROCEDURE asinl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  471.     EXTERNAL (*•• C*);
  472. PROCEDURE atanl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  473.     EXTERNAL (*•• C*);
  474. PROCEDURE atan2l*(y: LongDouble; x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  475.     EXTERNAL (*•• C*);
  476.  
  477. PROCEDURE coshl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  478.     EXTERNAL (*•• C*);
  479. PROCEDURE sinhl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  480.     EXTERNAL (*•• C*);
  481. PROCEDURE tanhl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  482.     EXTERNAL (*•• C*);
  483.  
  484. PROCEDURE acoshl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  485.     EXTERNAL (*•• C*);
  486. PROCEDURE asinhl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  487.     EXTERNAL (*•• C*);
  488. PROCEDURE atanhl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  489.     EXTERNAL (*•• C*);
  490.  
  491. PROCEDURE expl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  492.     EXTERNAL (*•• C*);
  493. PROCEDURE expm1l*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  494.     EXTERNAL (*•• C*);
  495. PROCEDURE exp2l*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  496.     EXTERNAL (*•• C*);
  497.  
  498. PROCEDURE frexpl*(x: LongDouble; VAR exponent: LONGINT): LongDouble; (*ΔΔC;ΔΔ*)
  499.     EXTERNAL (*•• C*);
  500. PROCEDURE ldexpl*(x: LongDouble; n: LONGINT): LongDouble; (*ΔΔC;ΔΔ*)
  501.     EXTERNAL (*•• C*);
  502.  
  503. PROCEDURE logl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  504.     EXTERNAL (*•• C*);
  505. PROCEDURE log1pl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  506.     EXTERNAL (*•• C*);
  507. PROCEDURE log10l*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  508.     EXTERNAL (*•• C*);
  509. PROCEDURE log2l*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  510.     EXTERNAL (*•• C*);
  511.  
  512. PROCEDURE logbl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  513.     EXTERNAL (*•• C*);
  514. PROCEDURE scalbl*(x: LongDouble; n: LONGINT): LongDouble; (*ΔΔC;ΔΔ*)
  515.     EXTERNAL (*•• C*);
  516.  
  517. PROCEDURE fabsl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  518.     EXTERNAL (*•• C*);
  519. PROCEDURE hypotl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  520.     EXTERNAL (*•• C*);
  521. PROCEDURE powl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  522.     EXTERNAL (*•• C*);
  523. PROCEDURE sqrtl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  524.     EXTERNAL (*•• C*);
  525.  
  526. PROCEDURE erfl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  527.     EXTERNAL (*•• C*);
  528. PROCEDURE erfcl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  529.     EXTERNAL (*•• C*);
  530. PROCEDURE gammal*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  531.     EXTERNAL (*•• C*);
  532. PROCEDURE lgammal*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  533.     EXTERNAL (*•• C*);
  534.  
  535. PROCEDURE ceill*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  536.     EXTERNAL (*•• C*);
  537. PROCEDURE floorl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  538.     EXTERNAL (*•• C*);
  539. PROCEDURE rintl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  540.     EXTERNAL (*•• C*);
  541. PROCEDURE nearbyintl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  542.     EXTERNAL (*•• C*);
  543. PROCEDURE rinttoll*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  544.     EXTERNAL (*•• C*);
  545. PROCEDURE roundl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  546.     EXTERNAL (*•• C*);
  547. PROCEDURE roundtoll*(round: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  548.     EXTERNAL (*•• C*);
  549. PROCEDURE truncl*(x: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  550.     EXTERNAL (*•• C*);
  551. PROCEDURE remainderl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  552.     EXTERNAL (*•• C*);
  553. PROCEDURE remquol*(x: LongDouble; y: LongDouble; VAR quo: LONGINT): LongDouble; (*ΔΔC;ΔΔ*)
  554.     EXTERNAL (*•• C*);
  555. PROCEDURE copysignl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  556.     EXTERNAL (*•• C*);
  557. PROCEDURE fdiml*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  558.     EXTERNAL (*•• C*);
  559. PROCEDURE fmaxl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  560.     EXTERNAL (*•• C*);
  561. PROCEDURE fminl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  562.     EXTERNAL (*•• C*);
  563.  
  564. PROCEDURE modfl*(x: LongDouble; VAR iptrl: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  565.     EXTERNAL (*•• C*);
  566. PROCEDURE nanl*(tagp: ConstCStringPtr): LongDouble; (*ΔΔC;ΔΔ*)
  567.     EXTERNAL (*•• C*);
  568. PROCEDURE nextafterl*(x: LongDouble; y: LongDouble): LongDouble; (*ΔΔC;ΔΔ*)
  569.     EXTERNAL (*•• C*);
  570. PROCEDURE __fpclassify*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  571.     EXTERNAL (*•• C*);
  572. PROCEDURE __isnormal*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  573.     EXTERNAL (*•• C*);
  574. PROCEDURE __isfinite*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  575.     EXTERNAL (*•• C*);
  576. PROCEDURE __isnan*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  577.     EXTERNAL (*•• C*);
  578. PROCEDURE __signbit*(x: LongDouble): LONGINT; (*ΔΔC;ΔΔ*)
  579.     EXTERNAL (*•• C*);
  580.  
  581. (*$IF UNDEFINED __NOEXTENSIONS__ *)
  582. PROCEDURE relationl*(x: LongDouble; y: LongDouble): relop; (*ΔΔC;ΔΔ*)
  583.     EXTERNAL (*•• C*);
  584. PROCEDURE x80told*(x80: Extended80; VAR x: LongDouble); (*ΔΔC;ΔΔ*)
  585.     EXTERNAL (*•• C*);
  586. PROCEDURE ldtox80*(x: LongDouble; VAR x80: Extended80); (*ΔΔC;ΔΔ*)
  587.     EXTERNAL (*•• C*);
  588.  
  589. (*    MathLib v2 has two new transfer functions: x80tod and dtox80.  They can 
  590.       be used to directly transform 68k 80-bit extended data types to double
  591.       and back for PowerPC based machines without using the functions
  592.       x80told or ldtox80.  Double rounding may occur.                         
  593. *)
  594. PROCEDURE x80tod*((*CONST*)VAR x80: Extended80): Double; (*ΔΔC;ΔΔ*)
  595.     EXTERNAL (*•• C*);
  596. PROCEDURE dtox80*((*CONST*)VAR x: Double; VAR x80: Extended80); (*ΔΔC;ΔΔ*)
  597.     EXTERNAL (*•• C*);
  598.  
  599. PROCEDURE num2decl*((*CONST*)VAR f: Decform; x: LongDouble; VAR d: Decimal); (*ΔΔC;ΔΔ*)
  600.     EXTERNAL (*•• C*);
  601. PROCEDURE dec2numl*((*CONST*)VAR d: Decimal): LongDouble; (*ΔΔC;ΔΔ*)
  602.     EXTERNAL (*•• C*);
  603. (*$END*) (* __NOEXTENSIONS__ *)
  604.  
  605. (*$END*) (* GENERATINGPOWERPC *)
  606.  
  607.  
  608.  
  609.  END fp.
  610.